﻿using System;
using System.Threading;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Text.RegularExpressions;
using System.IO;
using System.Linq;
namespace FeiYang
{
    public delegate void Func();
    public delegate bool 飞书传送_(挂机人物_ 人物);
    public delegate bool 快速到达_(坐标_ 要去的点);
    public delegate bool 过图操作_();
    public delegate bool 判断_();

    public delegate bool 使用包内物品_(挂机人物_ 人物, Point p);

    public enum 三态_
    {
        假_,
        真_,
        其他_
    }
    enum 消息类型_
    {
        消息 = 0,
        错误 = 1,
        警告 = 2,
        喜讯 = 3,
    }
    class 消息数据_
    {
        public 消息数据_(string 头部, string 内容) : this(头部, 内容, 消息类型_.消息)
        { }
        public 消息数据_(string 头部, string 内容, 消息类型_ 消息)
        {
            this.头部 = 头部;
            this.内容 = 内容;
            this.消息类型 = 消息;
        }
        public override string ToString()
        {
            return this.头部 +  this.内容;
        }

        public string 头部 { get; private set; }
        public string 内容 { get; private set; }
        public 消息类型_ 消息类型 { get; set; }
    }
    class 其他_
    {
        public static int 时长_50 = 50;
        public static int 时长_100 = 100;
        public static int 时长_200 = 200;
        public static int 时长_400 = 时长_200 * 2;
        public static int 时长_600 = 时长_200 * 3;
        public static int 时长_800 = 时长_200 * 4;
        public static int 时长_1000 = 时长_200 * 5;
        public static int 时长_1200 = 时长_200 * 6;
        public static int 时长_1400 = 时长_200 * 7;
        public static int 时长_1800 = 时长_200 * 8;
        public static int 时长_2000 = 时长_200 * 10;
        public static int 时长_3000 = 时长_200 * 15;
        public static int 时长_5000 = 时长_200 * 25;
        public static int 时长_10000 = 时长_200 * 50;

        public static CancellationTokenSource cts = new CancellationTokenSource();

        public static Random R = new Random();

        private static Point[] 屏幕有效范围 = new Point[]
             {
                    new Point(300,280),
                    new Point(300,72),
                    new Point(360,72),
                    new Point(360,46),
                    new Point(980,46),
                    new Point(980,207),
                    new Point(1104,207),
                    new Point(1104,290),
                    new Point(950,290),
                    new Point(950,404),
                    new Point(1189,404),
                    new Point(1089,477),
                    new Point(936,477),
                    new Point(936,579),
                    new Point(274,579),
                    new Point(274,717),
                    new Point(5,717),
                    new Point(5,280)
            };
        public static int 随机数(int 最大值)
        {
            return R.Next(最大值);
        }

        public static int 随机加或减去指定数(int 值, int 增减值, int 范围值 = 20)
        {
            var r = 随机数(范围值);
            if (r /2 == 0)
            {
                return 值 +r * 增减值;
            }
            else
            {
                return Math.Abs(值 - r * 增减值);
            }
        }

        public static void 延迟(int 时长)
        {
            Thread.Sleep(时长);
        }

        public static void 打印(string 内容, 消息类型_ 类型 = 消息类型_.消息)
        {
            var _this = MainWindow._this;
            DateTime now = DateTime.Now;
            var 数据 = new 消息数据_(now.ToString("HH:mm:ss") + ": " ,内容);
            if (类型 != 消息类型_.消息) 数据.消息类型 = 类型;
            if (_this.listBox.Items.Count == 0)
            {
                _this.Dispatcher.Invoke(() =>
                {
                    _this.listBox.Items.Add(数据);
                    _this.listBox.ScrollIntoView(_this.listBox.Items[_this.listBox.Items.Count - 1]);
                });
                return;
            }
            var 最后一条 = (消息数据_)_this.listBox.Items[_this.listBox.Items.Count - 1];
            if (最后一条.内容 != 内容)
            {
                _this.Dispatcher.Invoke(() =>
                {
                    _this.listBox.Items.Add(数据);
                    _this.listBox.ScrollIntoView(_this.listBox.Items[_this.listBox.Items.Count - 1]);
                });
            }
            if (_this.listBox.Items.Count >= 1000)
            {
                _this.listBox.Items.Clear();
            }
            return;
        }

        public static int 尝试编译数字(string 内容)
        {
            try
            {
                return Convert.ToInt32(内容.Trim(), 10);
            }
            catch (Exception _)
            {
                return 0;
            }
        }
        public static int 尝试编译带斜杠号数字的分子(string 内容)
        {
            try
            {
                var n = 内容.Split('/');
                if (n.Length > 0)
                {
                    var n1 = Regex.Replace(n[0], "[^0-9]", "");
                    return Convert.ToInt32(n1.Trim(), 10);
                }
                return -1;
            }
            catch (Exception _)
            {
                return -1;
            }
        }

        public static Point 取中心(int x, int y, int x2, int y2)
        {
            return new Point((int)(x + (x2 - x) / 2), (int)(y + (y2 - y) / 2));
        }
        public static Point 取中心(Rectangle rect)
        {
            return new Point((int)(rect.Left + rect.Width / 2), (int)(rect.Top + rect.Height / 2));
        }

        public static bool 点在有效范围内(Rectangle 范围 ,Point 测试点)
        {
            GraphicsPath 多边形 = new GraphicsPath();
            多边形.AddRectangle(范围);
            多边形.CloseFigure();
            return 多边形.IsVisible(测试点);
        }

        public static bool 点在有效范围内(Point 测试点)
        {
            GraphicsPath 多边形 = new GraphicsPath();
            多边形.AddPolygon(屏幕有效范围);
            多边形.AddEllipse(133, 539, 195 - 133, 603- 539);
            多边形.CloseFigure();
            return 多边形.IsVisible(测试点);
        }

        public static bool 字符出现过(string 要检测的文本, string 目标文本, int 次数 = 2)
        {
            var i = 0;
            foreach (var c in 目标文本)
            {
                if (要检测的文本.Contains(c.ToString()))
                {
                    i++;
                }
                if (i >= 目标文本.Length || i >= 次数)
                {
                    return true;
                }
            }
            return false;
        }
        public static bool 循环判断(判断_ func, int 最大次数 = 1, int 单次时长 = 1000)
        {
            if (最大次数 == 1)
            {
                延迟(单次时长);
                return func();
            }
            var i = 0;
            do
            {
                延迟(单次时长);
                i++;
                if (func()) return true;
            }
            while (i < 最大次数);
            return false;
        }

    }
}
